﻿// 0730train02.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <stack>
#include <unordered_set>

using namespace std;

/*
 给你两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。

输入
nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3

输出
[1,2,2,3,5,6]

 */


void solve01(vector<int>& nums1, int m, vector<int>& nums2, int n)
{
    vector<int>oh_vec_2 = nums2;

    int vec_size_1 = m+n;
    int vec_size_2 = n;

    int vec_index_1 = vec_size_1 - vec_size_2 - 1;
    int vec_index_2 = vec_size_2 - 1;

    //nums1 = [1,2,3,0,0,0], nums2 = [2,5,6]
    for (int i = vec_size_1 - 1; i >= 0; i--)
    {

        if (vec_index_1 >= 0 && vec_index_2 >= 0 && nums1[vec_index_1] >= oh_vec_2[vec_index_2])
        {
            nums1[i] = nums1[vec_index_1];
            vec_index_1 -= 1;
        }
        else if (vec_index_2 >= 0)
        {
            nums1[i] = nums2[vec_index_2];
            vec_index_2 -= 1;
        }

    }

    for (auto&item: nums1)
    {
        cout << item << ' ';
    }

    //solve01
    //------
}


/*
 给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，
 返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
由于在某些语言中不能改变数组的长度，
所以必须将结果放在数组nums的第一部分。
更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
 */
//输入：nums = [1,1,2]
//输出：2, nums = [1, 2, _]

void solve02(vector<int>& nums)
{
    unordered_set<int>oh_set;

    for (int i=0; i<nums.size(); i++)
    {

        if (oh_set.count(nums[i]))
        {
            nums.erase(nums.begin() + i);
            i--;
        }
    	else
        {
            oh_set.insert(nums[i]);
        }

        //for------
    }


    for (auto&item:nums)
    {
        cout << item << ' ';
    }

    //solve02
    //------
}


/*
 给你一个有序数组 nums ，请你 原地 删除重复出现的元素，
 使得出现次数超过两次的元素只出现两次 ，
 返回删除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。
 */

void solve03(vector<int>& nums)
{
    int slow = 0;
    for (int fast=0; fast<nums.size(); fast++)
    {
        if (slow<2 ||nums[fast]!=nums[slow-2])
        {
            nums[slow] = nums[fast];
            slow++;
        }

    }
    cout << slow;
    

    //solve03------
    //------
}


/*
 给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。
示例 1：
输入：nums = [1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.
示例 2:
输入：nums = [1,0,1,1,0,1]
输出：2
 */

void solve04(vector<int>& nums)
{
    int result = 0;

    int curr_count = 0;
    for (int i=0; i<nums.size();i++)
    {
        int curr_num = nums[i];

        if (curr_num==1)
        {
            curr_count += 1;
            result = max(curr_count, result);
        }
        else
        {
            curr_count = 0;
        }
        //for------
    }

    cout << curr_count;
	//solve04
    //------
}


/*
 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，
 同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

 */

void solve05(vector<int>& nums)
{
    
    int count = 0;
    for (int i=0; i<nums.size();i++)
    {
        if (nums[i]==0)
        {
            nums.erase(nums.begin() + i);
            i--;
            count++;
        }

        //for------
    }

    //cout << "count: " << count << endl;

    while (count--)
    {
        nums.push_back(0);
    }

    for (auto&n : nums)
    {
        cout << n << ' ';
    }

	//solve05
    //------
}


/*
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。
元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
 */

void solve06(vector<int>& nums, int val)
{
    for (int i=0; i<nums.size();i++)
    {
        if (nums[i]==val)
        {
            nums.erase(nums.begin() + i);
            i--;
        }


        //for------
    }
    cout << nums.size();
    //solve06
    //------
}


/*
定义当一个字符串只有元音字母(a,e,i,o,u,A,E,I,O,U)组成,称为元音字符串，
现给定一个字符串，请找出其中最长的元音字符串，并返回其长度，如果找不到请返回0。
字符串中任意一个连续字符组成的子序列称为该字符串的子串。
输入
一个字符串s。字符串长度满足0 < len(s) < 10^5，字符串仅由字符a-z或A-Z组成
输出描述
一个整数，表示最长的元音字符子串的长度。

输入
asdbuiodevauufgh
输出
3

 */

unordered_set<char>GetTargetVec()
{
    string str = "a,e,i,o,u,A,E,I,O,U";
    vector<char>target_vec;
    stringstream oh_sstream(str);
    string token;
    while (getline(oh_sstream, token, ','))
    {
        target_vec.push_back(token[0]);
    }

    unordered_set<char>oh_set;
    for (auto& oh_char : target_vec)
    {
        oh_set.insert(oh_char);
    }
    return oh_set;
    //GetTargetVec
}

void solve07(string &oh_str)
{
    unordered_set<char>oh_set = GetTargetVec();

    int result = 0;
    int curr_count = 0;

    for (int i=0; i<oh_str.size();i++)
    {
        char curr_char = oh_str[i];
	    if (oh_set.count(curr_char))
	    {
            curr_count += 1;
            result = max(result, curr_count);
	    }
        else
        {
            curr_count = 0;
        }
    }
    cout << result;
    //solve07
    //------
}


int main()
{
	{
        string oh_str;
        cin >> oh_str;
        //string oh_str = "asdbuiodevauufgh";
        solve07(oh_str);
        return 0;
	}

	{
        vector<int>nums = { 3,2,2,3 };
        int val = 3;
        solve06(nums, val);
        return 0;
	}

	{
        vector<int>nums = { 0,1,0,3,12 };
        solve05(nums);
        return 0;
	}

	{
        vector<int>nums = { 1,1,0,1,1,1 };
        solve04(nums);
        return 0;
	}

	{

        vector<int>nums = { 1,1,1,2,2,3 };
        solve03(nums);
        return 0;
	}



	{
        vector<int>nums1 = { 1,1,2 };
        solve02(nums1);
        return 0;
	}

    vector<int>nums1 = { 1, 2, 3, 0, 0, 0 }, nums2 = { 2, 5, 6 };
    int m = 3, n = 3;
    solve01(nums1, m, nums2, n);
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
